Look at the original, uninstrumented download() bytecode right before the first areturn (the orig.txt dump, bci 160–192):                                                     
                                                                                                                                                                                
  160: invokestatic  DelayKt.delay(...)   // stack: [R]           R = delay() result                                                                                            
  163: dup                                // stack: [R, R]                                                                                                                      
  164: aload         7                    // stack: [R, R, S]     S = COROUTINE_SUSPENDED sentinel (var7)                                                                       
  166: if_acmpeq     178                  // pops R,S; if equal -> stack: [R]   (one dup of R survives)                                                                         
  ...                                                                                                                                                                           
  178: aload         4  ...  183: bastore // jacoco bookkeeping, stack-neutral -> still [R]                                                                                     
  184: aload         7                    // stack: [R, S]        pushes the sentinel AGAIN                                                                                     
  186: aload         4  ...  191: bastore // jacoco bookkeeping, stack-neutral -> still [R, S]                                                                                  
  192: areturn                            // returns S (top of stack); R is silently discarded                                                                                  
                                                                                                                                                                                
  This is completely legal, ordinary bytecode: kotlinc's suspend-dispatch pattern leaves a redundant duplicate value (R) underneath the actual return value (S), relying on the 
  fact that areturn is a terminal instruction — the JVM only cares about the top-of-stack value at return time and simply throws away everything else below it. There's no      
  verification problem in the original class because nothing executes after that areturn that would need a merged stack-map frame.                                              
                                                                                                                                                                                
  Now look at what MetricInstrumenter.getBeforeReturnInsnList (MetricInstrumenter.java:192-208) does to this exact ARETURN:                                                     
                                                                                                                                                                                
  int tmpIdx = newVar(size);                                                                                                                                                    
  InsnList insnList = wrapTryCatch(callMetric(metricProbe, node, new ReturnContext(tmpIdx, loadOpCode, returnType)));                                                           
  insnList.insert(new VarInsnNode(storeOpCode, tmpIdx));  // ASTORE tmpIdx  — prepended                                                                                         
  insnList.add(new VarInsnNode(loadOpCode, tmpIdx));      // ALOAD  tmpIdx  — appended                                                                                          

  It assumes the stack at an ARETURN site contains exactly one value — the thing being returned — and replaces the bare areturn with ASTORE tmp → [try{ metric-emission code    
  }catch] → ALOAD tmp → GOTO sharedReturn. That assumption is false for this call site: it pops only the top value (S, into var 9), but the redundant R sitting underneath is   
  not consumed by anything anymore, because the code that follows the store is no longer a terminal areturn — it's non-terminal metric-emission code (ldc/getstatic/invokestatic
  DebuggerContext.metric) that pushes and pops its own operands from scratch, oblivious to the stale R still sitting beneath it.                                                

   So in the instrumented class, at the point corresponding to bci 230 (aload 9, right after the invokestatic metric(...) call returns):                                         
  - Via normal fall-through (227 → 230): the real stack is [R] — one leftover item, never cleaned up.                                                                           
  - Via the inner exception handler (bci 320 pop; 321 goto 230): when an exception is thrown out of the metric-emission code, the JVM's exception-dispatch semantics clear the  
  entire operand stack down to just the thrown exception before entering the handler (per the JVM spec — this is mandatory, not optional). So after pop removes the exception,  
  the real stack there is genuinely [] — the leftover R is gone, wiped out by the exception dispatch, not by any instruction in the instrumentation's own code.                 
                                                                                                                                                                                
  Two different real stack depths (1 vs. 0) converge on the same label (bci 230) — that is exactly what "Inconsistent stackmap frames at branch target 230" is reporting. It's  
  not really a "bad/stale StackMapTable entry" bug so much as the instrumentation genuinely producing divergent stack depths on the two converging paths.